C:/Projekte/RAIS/common/FunctionRole.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;

using FunctionRoleAttributes = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.FunctionRoleAttribute>;
using UserTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.UserTypeData>;
using FunctionRoleValidationTypesByName = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.FunctionRole.ValidationType>;
using FunctionRoles = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.FunctionRole.FunctionRoleType>;

namespace RAIS.Common.UserManagement
{
    public class FunctionRole : DBObject
    {
                #region Enumerators
        public enum ValidationType
        {
            NeedsValidation = 0,
            Validates,
            DoesNotNeedValidation
        }
                public enum FunctionRoleType
                {
                        Administrator,
                        Regulator,
                        Licensee,
                        PublicBody,
                        Guest,
                        Other
                }
                #endregion

        #region Fields
                static Dictionary<ValidationType, ValidationTypeData> validationTypesDictionary; 
                static FunctionRoleValidationTypesByName validationTypesDictionaryByName; 
                static Dictionary<FunctionRoleType, FunctionRoleTypeData> functionRoleTypesDictionary;
                
                bool modified = false;                                              
                ValidationType validationType;                                                                          
        FunctionRoleAttributes attributes = new FunctionRoleAttributes();       
        FunctionRoleAttributes addedAttributes = new FunctionRoleAttributes();  
        FunctionRoleAttributes removedAttributes = new FunctionRoleAttributes();        
                UserTypes userTypes = new UserTypes();
                UserTypes addedUserTypes = new UserTypes();
                UserTypes removedUserTypes = new UserTypes();
                FunctionRoleType type;
        #endregion

                #region Properties

                static public ValidationType DefaltValidation
                {
                        get { return ValidationType.NeedsValidation; }
                }
                static public FunctionRoleType DefaltType
                {
                        get { return FunctionRoleType.Other; }
                }
                static public Dictionary<ValidationType, ValidationTypeData> ValidationTypesDictionary
                {
                        get { return validationTypesDictionary; }
                        set { validationTypesDictionary = value; }
                }
        static public FunctionRoleValidationTypesByName ValidationTypeNamesDictionary
                {
                        get { return validationTypesDictionaryByName; }
            set { validationTypesDictionaryByName = value; }
                }
                public static Dictionary<FunctionRoleType, FunctionRoleTypeData> FunctionRoleTypesDictionary
                {
                        get { return FunctionRole.functionRoleTypesDictionary; }
                        set { FunctionRole.functionRoleTypesDictionary = value; }
                }
        
        public ValidationType Validation
        {
            get { return this.validationType; }
            set 
            { 
                this.validationType = value;
                this.Modified = true;
            }
        }
                public ValidationTypeData ValidationData
                {
                        get { return validationTypesDictionary[this.validationType]; }
                }
        public FunctionRoleAttributes Attributes
        {
            get { return this.attributes; }
            set { this.attributes = value; }
        }
        public FunctionRoleAttributes AddedAttributes
        {
            get { return this.addedAttributes; }
            set { this.addedAttributes = value; }
        }
        public FunctionRoleAttributes RemovedAttributes
        {
            get { return this.removedAttributes; }
        }
                public UserTypes AddedUserTypes
                {
                        get { return this.addedUserTypes; }
                }
                public UserTypes RemovedUserTypes
                {
                        get { return this.removedUserTypes; }
                }
        public bool Modified
        {
            get { return this.modified; }
            set 
            {
                if (!value)
                {
                    this.RemovedAttributes.Clear();
                    this.AddedAttributes.Clear();
                                        this.RemovedUserTypes.Clear();
                                        this.AddedUserTypes.Clear();
                }
                this.modified = value; 
            }
        }
                public UserTypes UserTypes
                {
                        get { return this.userTypes; }
                        set     { this.userTypes = value; }
                }
                public FunctionRoleType Type
                {
                        get 
                        {
                                //FunctionRoleType type = FunctionRoleType.Other;
                                //try
                                //{
                                //    type = (FunctionRoleType)Enum.Parse(typeof(FunctionRoleType), this.name);
                                //}
                                //catch {}
                                //return type;

                                return this.type;
                        }
                }
                public FunctionRoleTypeData TypeData
                {
                        get { return FunctionRoleTypesDictionary[this.type]; }
                }
                #endregion

        #region Constructors
        public FunctionRole()
        {
                        this.validationType = DefaltValidation;
                }
        public FunctionRole(IDataRecord record)
                {
                        this.ID = (int)record["PK Functional Role ID"];
            this.Name = record["Functional Role Name"].ToString();
                        this.validationType = (ValidationType)Enum.Parse(typeof(ValidationType), record["Validation Type Name"].ToString());
                        this.type = (FunctionRoleType)Enum.Parse(typeof(FunctionRoleType), record["Functional Role Type Name"].ToString());
                }
                #endregion

        #region Public methods

        public bool ContainsCategoryRestriction(string catregoryName)
        {
            foreach (FunctionRoleAttribute attribute in attributes.Values)
            {
                if (attribute.Category.Name == catregoryName)
                    return true;
            }
            return false;
        }
        public bool ContainsSubcategoryRestriction(FunctionRole.Category category, string subcatregoryName)
        {
            foreach (FunctionRoleAttribute attribute in attributes.Values)
            {
                if (attribute.Category.Name == category.Name &&
                    attribute.Subcategory.Name == subcatregoryName)
                    return true;
            }
            return false;
        }
        public bool ContainsMaskRestriction(FunctionRole.Category category,
                                            FunctionRole.Subcategory subcategory, 
                                            string maskName)
        {
            foreach (FunctionRoleAttribute attribute in attributes.Values)
            {
                if (attribute.Category.Name == category.Name &&
                    attribute.Subcategory.Name == subcategory.Name &&
                    attribute.Mask.Name == maskName)
                    return true;
            }
            return false;
        }
        public bool ValidateNewAttribute(FunctionRoleAttribute newAttribute, ref string returnMessage)
        {
            FunctionRoleAttributes funcitonRoleAttributes = this.Attributes;
            if (this.Attributes.ContainsKey(newAttribute.ToString()))
            {
                returnMessage = RAIS.Common.Messages.FUNCTION_ROLE_ATTRIBUTE_EXISTS;
                return false;
            }
            else
            if(this.RestricitonsConflict(newAttribute) )
            {
                returnMessage = RAIS.Common.Messages.FUNCTION_ROLE_ATTRIBUTE_CONFLICT;
                return false;
            }
            else
                return true;
        }

        public bool AddAttribute(FunctionRoleAttribute newAttribute, ref string returnMessage)
        {
            bool success = this.ValidateNewAttribute(newAttribute, ref returnMessage);
            if (success)
            {
                //if( this.RemovedAttributes.ContainsKey(newAttribute.ToString()))
                //    this.RemovedAttributes.Remove(newAttribute.ToString());
                //else
                    this.AddedAttributes.Add(newAttribute.ToString(), newAttribute);
                
                this.Attributes.Add(newAttribute.ToString(), newAttribute);

                this.Modified = true;
            }
            return success;
        }
        public bool RemoveAttribute(FunctionRoleAttribute removedAttribute, ref string returnMessage)
        {
            if (this.AddedAttributes.ContainsKey(removedAttribute.ToString()))
                this.AddedAttributes.Remove(removedAttribute.ToString());
            else
                this.RemovedAttributes.Add(removedAttribute.ToString(), removedAttribute);

            this.Attributes.Remove(removedAttribute.ToString());
            this.Modified = true;
            return true;
        }

                public bool AddUserType(UserTypeData newUserType, ref string returnMessage)
                {
                        if (this.RemovedUserTypes.ContainsKey(newUserType.VisibleName))
                                this.RemovedUserTypes.Remove(newUserType.VisibleName);
                        else
                                this.AddedUserTypes.Add(newUserType.VisibleName, newUserType);

                        this.UserTypes.Add(newUserType.VisibleName, newUserType);
                        this.Modified = true;
                        return true;
                }

                public bool RemoveUserType(UserTypeData removedUserType, ref string returnMessage)
                {
            bool success = this.ValidateRemoveUserType(removedUserType, ref returnMessage);
                        if (success)
                        {
                                if (this.AddedUserTypes.ContainsKey(removedUserType.VisibleName))
                                        this.AddedUserTypes.Remove(removedUserType.VisibleName);
                                else
                                        this.RemovedUserTypes.Add(removedUserType.VisibleName, removedUserType);

                                this.UserTypes.Remove(removedUserType.VisibleName);
                                this.Modified = true;
                        }
                        return success;
                }

                public FunctionRoleAttribute GetAttributeByIndex(int index)
                {
                        FunctionRoleAttribute attribute = null;

                        if (this.attributes.Count >= index)
                        {
                                int i = 0;
                                foreach (KeyValuePair<string, FunctionRoleAttribute> kvp in this.attributes)
                                {
                                        if (i == index)
                                        {
                                                attribute = kvp.Value;
                                                break;
                                        }
                                        i++;
                                }
                        }

                        return attribute;
                }
                #endregion

        #region Private helper methods
        private bool RestricitonsConflict(FunctionRoleAttribute newAttribute)
        {
            FunctionRoleAttributes funcitonRoleAttributes = this.Attributes;
            foreach (FunctionRoleAttribute attribute in funcitonRoleAttributes.Values)
            {
                if (newAttribute.RestricitonsConflict(attribute))
                {
                    return true;
                }
            }
            return false;
        }

                private bool ValidateRemoveUserType(UserTypeData removedUserType, ref string returnMessage)
                {
                        bool success = true;
                        return success;
                }
        #endregion

        #region Nested classes

        public class Category : DBObject
        {
                    #region Constructors
            public Category()
            {}
            public Category(IDataRecord record)
                    {
                                this.ID = (int)record["PK Category ID"];
                                this.Name = record["Category Name"].ToString();
            }
                    #endregion
            #region Public methods
            public bool RestricitonsConflict(Category category)
            {
                if (category.Name == RAIS.Common.Constants.ALL_CATEGORIES &&
                    this.Name != RAIS.Common.Constants.ALL_CATEGORIES)
                    return true;
                else
                    if (this.Name == RAIS.Common.Constants.ALL_CATEGORIES &&
                        category.Name != RAIS.Common.Constants.ALL_CATEGORIES)
                        return true;
                    else
                        return false;
            }
            #endregion
        }
        public class Subcategory : DBObject
                {
                        #region Fields
                        Category parent;
                        bool customSubcategory = true;
                        int order = 0;
                        int imageIndex = 0;
                        #endregion
                        #region Properties

                        public Category Parent
                        {
                                get { return this.parent; }
                                set { this.parent = value; }
                        }
                        public string FullName
                        {
                get
                {
                    if (this.Parent != null)
                        return this.Parent.Name + Constants.SEPARATOR + this.Name;
                    else
                        return this.Name;
                }
                        }
                        public bool CustomSubcategory
                        {
                                get { return customSubcategory; }
                                set { customSubcategory = value; }
                        }
                        public int Order
                        {
                                get { return order; }
                                set { order = value; }
                        }
                        public int ImageIndex
                        {
                                get { return imageIndex; }
                                set { imageIndex = value; }
                        }
                        #endregion
                        #region Constructors
                        public Subcategory()
            { }
            public Subcategory(IDataRecord record)
            {
                this.ID = (int)record["PK Subcategory ID"];
                this.Name = record["Subcategory Name"].ToString();
                                this.parent = new Category(record);
                                this.customSubcategory = (int.Parse(record["Custom Subcategory"].ToString()) == 1);
                                this.order = (int)record["Order"];
                        }
            #endregion
            #region Public methods
            public bool RestricitonsConflict(Subcategory subcategory)
            {
                if (subcategory.Name == RAIS.Common.Constants.ALL_SUBCATEGORIES &&
                    this.Name != RAIS.Common.Constants.ALL_SUBCATEGORIES)
                    return true;
                else
                    if (subcategory.Name != RAIS.Common.Constants.ALL_SUBCATEGORIES &&
                        this.Name == RAIS.Common.Constants.ALL_SUBCATEGORIES)
                        return true;
                    else
                        return false;
            }
            #endregion
        }
                public class ValidationTypeData
                {
                        #region Fields
                        int id;
                        string name;
                        string visibleName;
                        #endregion

                        #region Properties
                        public int ID
                        {
                                get { return this.id; }
                        }
                        public ValidationType Type
                        {
                                get { return (ValidationType)Enum.Parse(typeof(ValidationType), this.name); }
                        }
                        public string VisibleName
                        {
                                get { return this.visibleName; }
                        }
                        #endregion

                        #region Constructors
                        public ValidationTypeData(IDataRecord record)
                        {
                                this.id = (int)record["PK Functional Role Validation Type ID"];
                                this.name = record["Validation Type Name"].ToString();
                                this.visibleName = record["Validation Type Visible Name"].ToString();
                        }
                        #endregion
                }
                public class FunctionRoleTypeData
                {
                        #region Fields
                        int id;
                        string name;
                        string visibleName;
                        #endregion

                        #region Properties
                        public int ID
                        {
                                get { return this.id; }
                        }
                        public FunctionRoleType Type
                        {
                                get { return (FunctionRoleType)Enum.Parse(typeof(FunctionRoleType), this.name); }
                        }
                        public string VisibleName
                        {
                                get { return this.visibleName; }
                        }
                        #endregion

                        #region Constructors
                        public FunctionRoleTypeData(IDataRecord record)
                        {
                                this.id = (int)record["PK Functional Role Type ID"];
                                this.name = record["Functional Role Type Name"].ToString();
                                this.visibleName = record["Functional Role Type Visible Name"].ToString();
                        }
                        #endregion
                }
                #endregion
    }
}